#include "Jeu.h"

/* ------------------- QUELQUES INTERNES FONCTIONS UTILES ------------------------------*/
static void purger(void)
{
    int c;

    while ((c = getchar()) != '\n' && c != EOF)
    {}
}


/*------------------------------ FONCTIONS EXTERNES ---------------------------------*/
void jeuInit(Jeu* pJeu)
{
    int i;
    printf("Entrez le nombre de joueur: ");
    scanf("%d",&(pJeu->nbJoueurs));
    pJeu->tabJoueurs=(Joueur **) malloc(pJeu->nbJoueurs*sizeof(Joueur *));
    for(i=0;i<pJeu->nbJoueurs;i++)
    {

        pJeu->tabJoueurs[i]=malloc(sizeof(Joueur));
        assert(pJeu->tabJoueurs[i] !=  NULL);
        jInitaliser(pJeu->tabJoueurs[i],i+1);
        purger();


    }
    pJeu->pChev=(Chevalet *) malloc(sizeof(Chevalet));
    chevInitialiser(pJeu->pChev);
    pJeu->pTer=(Terrain *) malloc(sizeof(Terrain));
    terInitialiser(pJeu->pTer);
}

void jeuLib(Jeu * pJeu)
{ int i;
     for(i=0;i<pJeu->nbJoueurs;i++)
    {
        free(pJeu->tabJoueurs[i]);
    }

    pJeu->nbJoueurs=0;

    free(pJeu->tabJoueurs);
    pJeu->tabJoueurs=NULL;



    chevLiberer(pJeu->pChev);
    free(pJeu->pChev);
    pJeu->pChev=NULL;

    terLiberer(pJeu->pTer);
    free(pJeu->pTer);
    pJeu->pTer=NULL;
}

Terrain * jeuGetTerrain(const Jeu *pJeu)
{
    return pJeu->pTer;
}

Chevalet * jeuGetChev(const Jeu *pJeu)
{
    return pJeu->pChev;
}

void reInitTer(Jeu *pJeu)
{

    terLiberer(pJeu->pTer);
    terInitialiser(pJeu->pTer);
}

void reInitChev(Jeu *pJeu)
{

    chevLiberer(pJeu->pChev);
    chevInitialiser(pJeu->pChev);
}

/* Le joueur marque autant de point que la longueur de son mot */
unsigned int jeuCalculScore(const int *x, const int *y,const int res_formeMot,const Terrain * pTer, const int taille)
{
    unsigned int min,max,tailleMot;
    tailleMot=0;



    /*si notre mot est écrit à l'horizontal*/
    if(res_formeMot==1)
    /* on vérifie sa longueur totale*/
     {
         /* on commence par chercher où le joueur a posé des lettres*/
         min=rechercheMin(y,taille);
         max=rechercheMax(y,taille);
         /* on regarde si il y en avait (des lettres) avant */
         while(terGetXY(pTer,x[0],min-1)!='.' && min!=1) {min--;}
         /* on regarde si il y a des lettres après celles jouées */
         while(terGetXY(pTer,x[0],max+1)!='.' && max!=9) {max++;}
     }

   /*si notre mot est écrit à la vertical*/
    if(res_formeMot==2)
    /* on vérifie sa longueur totale*/
     {
         /* on commence par chercher où le joueur a posé des lettres*/
         min=rechercheMin(x,taille);
         max=rechercheMax(x,taille);
         /* on regarde si il y en avait (des lettres) avant */
         while(terGetXY(pTer,min-1,y[0])!='.' && min!=1) {min--;}
         /* on regarde si il y a des lettres après celles jouées */
         while(terGetXY(pTer,max+1,y[0])!='.' && max!=9) {max++;}

     }

        tailleMot=max-min+1;

        return tailleMot;
}


void remettreLettreDansChev(Terrain * pTer,Chevalet * pChev,int * pTabX, int * pTabY,int nbLettrePose)
{
int j,chercheOuPoserLettre,indiceRetourChev;
char lettre;
    for(j=0;j<nbLettrePose;j++)
     {

        for(chercheOuPoserLettre=0;chercheOuPoserLettre<6;chercheOuPoserLettre++)
          {
            if(chevTestCaseVide(pChev,chercheOuPoserLettre)==1)
                       {
                           indiceRetourChev=chercheOuPoserLettre;
                           chercheOuPoserLettre=6;
                       }
          }
     lettre=terGetXY(pTer,pTabX[j],pTabY[j]);
     pChev->tabLettres[indiceRetourChev]=lettre;
     terSetXY(pTer,pTabX[j],pTabY[j],'.');
    }
nbLettrePose=0;
}

void testRegression_Jeu()
{
    Jeu j;

    jeuInit(&j);
    assert(j.nbJoueurs!=0 && j.tabJoueurs!=NULL && j.pTer!=NULL && j.pChev!=NULL);
    printf("jeuInit() OK...\n");

    assert(jeuGetChev(&j)==j.pChev);
    printf("jeuGetChev() OK...\n");

    assert(jeuGetTerrain(&j)==j.pTer);
    printf("jeuGetTerrain() OK...\n");

    jeuLib(&j);
    assert(j.nbJoueurs==0 && j.tabJoueurs==NULL && j.pTer==NULL && j.pChev==NULL);
    printf("jeuLib() OK...\n");
}
